// 云开发管理工具类 - 采用单例模式实现
let instance = null;

class CloudManager {
  constructor() {
    // 云数据库引用
    this.db = wx.cloud.database();
    // 云存储引用
    this.storage = wx.cloud;
  }
  
  /**
   * 获取云开发管理器的单例实例
   * @returns {CloudManager} 云开发管理器实例
   */
  static getInstance() {
    if (!instance) {
      instance = new CloudManager();
    }
    return instance;
  }
  
  /**
   * 调用云函数的统一方法
   * @param {string} name - 云函数名称
   * @param {Object} data - 传递给云函数的参数
   * @returns {Promise} - 云函数调用结果的Promise
   */
  callFunction(name, data = {}) {
    return new Promise((resolve, reject) => {
      wx.cloud.callFunction({
        name,
        data,
        success: res => resolve(res.result),
        fail: err => reject(err)
      });
    });
  }
  
  /**
   * 获取用户信息
   * @returns {Promise} - 用户信息的Promise
   */
  getUserInfo() {
    return this.callFunction('login');
  }
  
  /**
   * 更新用户信息
   * @param {Object} userInfo - 用户信息
   * @returns {Promise} - 更新结果的Promise
   */
  updateUserInfo(userInfo) {
    return this.callFunction('updateUser', { userInfo });
  }
  
  /**
   * 获取数据
   * @param {string} collection - 集合名称
   * @param {Object} query - 查询条件
   * @returns {Promise} - 查询结果的Promise
   */
  getData(collection, query = {}) {
    return this.callFunction('getData', { collection, query });
  }
  
  /**
   * 从云数据库直接获取数据
   * @param {string} collection - 集合名称
   * @param {Object} query - 查询条件
   * @param {Object} options - 查询选项
   * @param {number} options.skip - 跳过条数
   * @param {number} options.limit - 限制条数
   * @param {string} options.orderBy - 排序字段
   * @param {string} options.order - 排序方式
   * @returns {Promise} - 查询结果的Promise
   */
  async getFromDb(collection, query = {}, options = {}) {
    const { skip = 0, limit = 20, orderBy = '_id', order = 'asc' } = options;
    try {
      const db = wx.cloud.database();
      const _ = db.command;
      
      let dbQuery = db.collection(collection).where(query);
      
      // 添加排序
      dbQuery = dbQuery.orderBy(orderBy, order);
      
      // 添加分页
      dbQuery = dbQuery.skip(skip).limit(limit);
      
      const result = await dbQuery.get();
      return result.data;
    } catch (error) {
      console.error('从云数据库获取数据失败', error);
      throw error;
    }
  }
  
  /**
   * 向云数据库添加数据
   * @param {string} collection - 集合名称
   * @param {Object} data - 要添加的数据
   * @returns {Promise} - 添加结果的Promise
   */
  async addToDb(collection, data) {
    try {
      const db = wx.cloud.database();
      // 添加创建时间
      const insertData = {
        ...data,
        createdAt: db.serverDate(),
        updatedAt: db.serverDate()
      };
      
      const result = await db.collection(collection).add({
        data: insertData
      });
      return result;
    } catch (error) {
      console.error('向云数据库添加数据失败', error);
      throw error;
    }
  }
  
  /**
   * 更新云数据库中的数据
   * @param {string} collection - 集合名称
   * @param {string} docId - 文档ID
   * @param {Object} data - 要更新的数据
   * @returns {Promise} - 更新结果的Promise
   */
  async updateDb(collection, docId, data) {
    try {
      const db = wx.cloud.database();
      // 添加更新时间
      const updateData = {
        ...data,
        updatedAt: db.serverDate()
      };
      
      const result = await db.collection(collection).doc(docId).update({
        data: updateData
      });
      return result;
    } catch (error) {
      console.error('更新云数据库数据失败', error);
      throw error;
    }
  }
  
  /**
   * 删除云数据库中的数据
   * @param {string} collection - 集合名称
   * @param {string} docId - 文档ID
   * @returns {Promise} - 删除结果的Promise
   */
  async deleteFromDb(collection, docId) {
    try {
      const db = wx.cloud.database();
      const result = await db.collection(collection).doc(docId).remove();
      return result;
    } catch (error) {
      console.error('从云数据库删除数据失败', error);
      throw error;
    }
  }
  
  /**
   * 上传文件到云存储
   * @param {string} filePath - 本地文件路径
   * @param {string} cloudPath - 云存储路径，不传则自动生成
   * @returns {Promise} - 上传结果的Promise
   */
  uploadFile(filePath, cloudPath = '') {
    return new Promise((resolve, reject) => {
      if (!cloudPath) {
        // 生成随机文件名
        const timestamp = Date.now();
        const random = Math.floor(Math.random() * 1000);
        const ext = filePath.split('.').pop();
        cloudPath = `upload/${timestamp}_${random}.${ext}`;
      }
      
      wx.cloud.uploadFile({
        cloudPath,
        filePath,
        success: res => resolve(res),
        fail: err => reject(err)
      });
    });
  }
  
  /**
   * 从云存储下载文件
   * @param {string} fileID - 云存储文件ID
   * @returns {Promise} - 下载结果的Promise
   */
  downloadFile(fileID) {
    return new Promise((resolve, reject) => {
      wx.cloud.downloadFile({
        fileID,
        success: res => resolve(res),
        fail: err => reject(err)
      });
    });
  }
  
  /**
   * 获取文件临时链接
   * @param {Array} fileList - 文件ID列表
   * @returns {Promise} - 临时链接列表的Promise
   */
  getTempFileURL(fileList) {
    return new Promise((resolve, reject) => {
      wx.cloud.getTempFileURL({
        fileList,
        success: res => resolve(res.fileList),
        fail: err => reject(err)
      });
    });
  }
}

// 导出类和单例实例
module.exports = {
  CloudManager,
  getInstance: CloudManager.getInstance
};

module.exports = CloudManager;